import ValidateIdent from "@/common/validateIdentity";

export const validateFun = {
    // 验证电话
    phone(value: string | number): boolean
    {
        return new RegExp(regular.phone).test(value.toString());
    },
    // 验证邮箱
    email(value: string): boolean
    {
        return new RegExp(regular.email).test(value);
    },
    // 验证正整数
    positiveInteger(value: string | number): boolean
    {
        return new RegExp(regular.positiveInteger).test(value.toString());
    },
    // 验证非负数字
    unNegativeNumber(value: string | number): boolean
    {
        return new RegExp(regular.unNegativeNumber).test(value.toString());
    },
    // 验证非负整数（含0）
    nonnegativeInteger(value: string | number): boolean
    {
        return new RegExp(regular.nonnegativeInteger).test(value.toString());
    },
    // 验证负整数
    negativeInteger(value: string | number): boolean
    {
        return new RegExp(regular.negativeInteger).test(value.toString());
    },
    // 验证非零整数
    nonzeroInteger(value: string | number): boolean
    {
        return new RegExp(regular.nonzeroInteger).test(value.toString());
    },
    // 验证数字
    number(value: string | number): boolean
    {
        return new RegExp(regular.number).test(value.toString());
    },
    // 验证整数、小数（非0）
    integerDecimalNumber(value: string | number): boolean
    {
        return new RegExp(regular.integerDecimalNumber).test(value.toString());
    },
    // 验证浮点数
    float(value: string | number): boolean
    {
        return new RegExp(regular.float).test(value.toString());
    },
    // 验证非零浮点数
    nonzeroFloat(value: string | number): boolean
    {
        return new RegExp(regular.nonzeroFloat).test(value.toString());
    },
    // 验证正浮点数
    positiveFloat(value: string | number): boolean
    {
        return new RegExp(regular.positiveFloat).test(value.toString());
    },
    // 验证负浮点数
    negativeFloat(value: string | number): boolean
    {
        return new RegExp(regular.negativeFloat).test(value.toString());
    },
    // 验证非零正浮点数
    nonzeroPositiveFloat(value: string | number): boolean
    {
        return new RegExp(regular.nonzeroPositiveFloat).test(value.toString());
    },
    // 验证非零负浮点数
    nonzeroNegativeFloat(value: string | number): boolean
    {
        return new RegExp(regular.nonzeroNegativeFloat).test(value.toString());
    },
    // 验证中文和字母（不含数字）
    alphabet(value: string): boolean
    {
        return new RegExp(regular.alphabet).test(value.toString());
    },
    // 验证min
    min(value: number, validateValue: number): boolean
    {
        return value >= validateValue;
    },
    // 验证max
    max(value: number, validateValue: number): boolean
    {
        return value <= validateValue;
    },
    // 验证minLength
    minLength(value: string | number | Array<any>, validateValue: number): boolean
    {
        // 统计当前输入的字符数或数组长度
        let count = 0;

        if (isString(value))
        {
            count = value.length;
        }
        else if (isNumber(value))
        {
            count = value.toString().length;
        }
        else
        {
            count = value.length;
        }

        return count >= validateValue;
    },
    // 验证maxLength
    maxLength(value: string | number | Array<any>, validateValue: number): boolean
    {
        // 统计当前输入的字符数或数组长度
        let count = 0;

        if (isString(value))
        {
            count = value.length;
        }
        else if (isNumber(value))
        {
            count = value.toString().length;
        }
        else
        {
            count = value.length;
        }

        return count <= validateValue;
    },
    // 验证浮点数精度
    precision(value: string | number, validateValue: number): boolean
    {
        // 当前校验的数字
        let validateString = value;

        if (isNumber(validateString))
        {
            validateString = validateString.toString();
        }

        // 获取当前小数位
        const decimal = validateString.split(".")[1];

        if (decimal)
        {
            return decimal.length <= validateValue;
        }
        else
        {
            return true;
        }
    },
    // 验证between
    between(value: number, start: number, end: number): boolean
    {
        return value >= start && value <= end;
    },
    // 验证date
    date(value: string): boolean
    {
        return new RegExp(regular.date).test(value);
    },
    // 验证time
    time(value: string): boolean
    {
        return new RegExp(regular.time).test(value);
    },
    // 验证dateTime
    dateTime(value: string): boolean
    {
        return new RegExp(regular.dateTime).test(value);
    },
    // 验证身份证
    identityCard(value: string): boolean
    {
        const validateIdentity = new ValidateIdent();

        // return new RegExp(regular.identityCard).test(value);
        return validateIdentity.validate(value);
    },
    // 验证特殊字符
    special(value: string): boolean
    {
        const reg = new RegExp(regular.special);

        return !reg.test(value);
    },
    // 验证特殊字符（简易）
    simpleSpecial(value: string): boolean
    {
        const reg = new RegExp(regular.simpleSpecial);

        return !reg.test(value);
    },
    // 验证数字和字母
    letterNumber(value: string): boolean
    {
        return new RegExp(regular.letterNumber).test(value.toString());
    },
    // 验证护照
    passport(value: string): boolean
    {
        return new RegExp(regular.passport).test(value.toString());
    },
    // 验证regular
    regular(value: string, regular: string): boolean
    {
        return new RegExp(regular).test(value);
    }
};